home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
CU Amiga Super CD-ROM 17
/
CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso
/
CUCD
/
Programming
/
DiceSource
/
src
/
dd
/
commands.c
< prev
next >
Wrap
C/C++ Source or Header
|
1997-09-09
|
47KB
|
1,747 lines
/*
* (c)Copyright 1992-1997 Obvious Implementations Corp. Redistribution and
* use is allowed under the terms of the DICE-LICENSE FILE,
* DICE-LICENSE.TXT.
*/
#include "defs.h"
#include "dbug_protos.h"
Prototype void RefreshFKeys(BOOL fullRefresh);
Prototype BOOL FunctionKey(UWORD num);
Prototype BOOL HelpKey(void);
Prototype BOOL CmdFKey(char *args);
Prototype BOOL CmdRexx(char *args);
Prototype BOOL CmdSavePrefs(char *args);
Prototype BOOL CmdInfo(char *args);
Prototype BOOL CmdExecBase(char *args);
Prototype BOOL CmdResources(char *args);
Prototype BOOL CmdIntrs(char *args);
Prototype BOOL CmdPorts(char *args);
Prototype BOOL CmdSymList(char *args);
Prototype BOOL CmdTasks(char *args);
Prototype BOOL CmdLibs(char *args);
Prototype BOOL CmdDevices(char *args);
Prototype BOOL CmdMemList(char *args);
Prototype BOOL CmdDoBsBase(char *args);
Prototype BOOL CmdProcess(char *args);
Prototype BOOL CmdOffsets(char *args);
Prototype BOOL CmdDown(char *args);
Prototype BOOL CmdUp(char *args);
Prototype BOOL CmdPageDown(char *args);
Prototype BOOL CmdPageUp(char *args);
Prototype BOOL CmdSource(char *args);
Prototype BOOL CmdDism(char *args);
Prototype BOOL CmdMixed(char *args);
Prototype BOOL CmdBytes(char *args);
Prototype BOOL CmdWords(char *args);
Prototype BOOL CmdLongs(char *args);
Prototype BOOL CmdBreakpoint(char *args);
Prototype BOOL CmdBP(char *args);
Prototype BOOL CmdClear(char *args);
Prototype BOOL CmdHunks(char *args);
Prototype BOOL CmdSymbol(char *args);
Prototype BOOL CmdSet(char *args);
Prototype BOOL RStepTarget(void);
Prototype BOOL StepTarget(void);
Prototype BOOL StepTargetRange(ULONG addressLow, ULONG addressHi);
Prototype BOOL RStepTargetRange(ULONG addressLow, ULONG addressHi);
Prototype BOOL CmdStep(char *args);
Prototype BOOL CmdRStep(char *args);
Prototype BOOL OverTarget(void);
Prototype BOOL OverTargetRange(ULONG addressLow, ULONG addressHi);
Prototype BOOL CmdOver(char *args);
Prototype BOOL CmdReset(char *args);
Prototype BOOL GoTarget(void);
Local void CopyLastState(void);
Prototype BOOL CmdGo(char *args);
Prototype BOOL CmdEval(char *args);
Prototype BOOL CmdOpen(char *args);
Prototype BOOL CmdClose(char *args);
Prototype BOOL CmdQuit(char *args);
Prototype BOOL CmdHelp(char *args) ;
Prototype BOOL CmdWatchBytes(char *args);
Prototype BOOL CmdWatchWords(char *args);
Prototype BOOL CmdWatchLongs(char *args);
Prototype BOOL CmdWatchClear(char *args);
Prototype BOOL CmdRefresh(char *args);
Prototype BOOL CmdDosBase(char *args);
Prototype WORD RefreshHelp(WORD maxLines, BOOL fullRefresh, LONG);
Prototype BOOL DownHelp(void);
Prototype BOOL UpHelp(void);
Prototype int HelpSize(void);
Prototype char *SkipBlanks(char *s);
Prototype BOOL DoCommand(char *command);
Prototype BOOL CmdAlias(char *args);
Prototype BOOL CmdUnAlias(char *args);
Prototype BOOL CmdRegs(char *args);
Prototype BOOL CmdJump(char *args);
Prototype BOOL CmdBar(char *args);
Prototype BOOL CmdEnd(char *args);
Prototype BOOL CmdItem(char *args);
Prototype BOOL CmdTitle(char *args);
Prototype BOOL CmdMenus(char *args);
Prototype BOOL CmdSubItem(char *args);
Prototype BOOL CmdChangeWindow(char *args);
Prototype BOOL CmdAgain(char *args);
Local void ShortStatus(int mode, char *command);
Prototype void init_function_keys(void);
// ************
typedef struct CMDDEF {
char *helpText;
char *command;
UWORD commandLen;
BOOL (*func)(char *args);
} CMDDEF;
CMDDEF commandTable[] = {
// NOTE: These must be in alphabetical order
{ "again - repeat last command", "AGAIN", 5, CmdAgain },
{ "alias - replace command with arexx script", "ALIAS", 5, CmdAlias },
{ "bp {expr} - set breakpoint at expression", "BP", 2, CmdBP },
{ "bp ALL - set all breakpoints in table", "BP", 2, CmdBP },
{ "breakpoints - display breakpoint table", "BREAKPOINTS", 11, CmdBreakpoint },
{ "bytes {expr} - display bytes {at expression}", "BYTES", 5, CmdBytes },
{ "changewindow - move/size current window", "CHANGEWINDOW", 12, CmdChangeWindow },
{ "clear expr - clear breakpoint at expression", "CLEAR", 5, CmdClear },
{ "clear ALL - clear all breakpoints in table", "CLEAR", 5, CmdClear },
{ "close - close a display", "CLOSE", 5, CmdClose },
{ "devs - display Exec Device List", "DEVS", 4, CmdDevices },
{ "dism {expr} - change to dism mode {at expression}", "DISM", 4, CmdDism },
{ "dosbase - intelligent display of DOSBase struct", "DOSBASE", 7, CmdDosBase },
{ "down - move display down one line", "DOWN", 4, CmdDown },
{ "eval {expr} - evaluate an expression", "EVAL", 4, CmdEval },
{ "execbase - display ExecBase (SysBase)", "EXECBASE", 8, CmdExecBase },
{ "fkey - set function key definition", "FKEY", 4, CmdFKey },
{ "go {expr...} - set {expr...} temp breakpoints & go", "GO", 2, CmdGo },
{ "help - online help", "HELP", 4, CmdHelp },
{ "hunks - change to hunks mode", "HUNKS", 5, CmdHunks },
{ "info - display ThisTask info", "INFO", 4, CmdInfo },
{ "intrs - display Exec Intrs List", "INTRS", 5, CmdIntrs },
{ "jump {name} - jump to public screen", "JUMP", 4, CmdJump },
{ "libs - display Exec Libs List", "LIBS", 4, CmdLibs },
{ "longs {expr} - display longs {at expression}", "LONGS", 5, CmdLongs },
{ "mbar slot - add menu bar", "MBAR", 4, CmdBar },
{ "mend slot - add menu end mark", "MEND", 4, CmdEnd },
{ "memlist - display Exec Mem List", "MEMLIST", 6, CmdMemList },
{ "mitem {...} - add menu item", "MITEM", 5, CmdItem },
{ "mixed {expr} - change to mixed mode {at expression}", "MIXED", 5, CmdMixed },
{ "menus - activate a new set of user menus", "MENUS", 5, CmdMenus },
{ "msub {...} - add a sub menu item", "MSUB", 4, CmdSubItem },
{ "mtitle {...} - add menu title", "MTITLE", 6, CmdTitle },
{ "offsets - toggle display address/offsets", "OFFSETS", 7, CmdOffsets },
{ "open {type} - open a new display", "OPEN", 4, CmdOpen },
{ "over {expr} - stepover one instruction or range", "OVER", 4, CmdOver },
{ "pagedown - move display down one page", "PAGEDOWN", 8, CmdPageDown },
{ "pageup - move display up one page", "PAGEUP", 6, CmdPageUp },
{ "rendlist - end the arexx list", "RENDLIST", 8, RXEndList },
{ "rgetbyte {expr} - get bytes at {expr}", "RGETBYTE", 8, RXGetBytes },
{ "rgetcom - get command line input", "RGETCOM", 7, RXGetCommand },
{ "rgetdism {expr} - get the dissembled line", "RGETDISM", 8, RXGetDismLine },
{ "rgeteval {expr} - evaluate the expression", "RGETEVAL", 8, RXGetEval },
{ "rgetinfo {expr} - get the program name and line number", "RGETINFO", 8, RXGetInfo },
{ "rgetline {expr} - return the source/mixed line", "RGETLINE", 8, RXGetLine },
{ "rgetlong {expr} - get longs at {expr}", "RGETLONG", 8, RXGetLongs },
{ "rgetword {expr} - get words at {expr}", "RGETWORD", 8, RXGetWords },
{ "rgetpc - return the program counter", "RGETPC", 6, RXGetPC },
{ "rputlist - add an item to the arexx list", "RPUTLIST", 8, RXPutList },
{ "rshowlist - show the arexx list", "RSHOWLIST", 9, RXEndList },
{ "rstartlist - start the arexx list", "RSTARTLIST", 10, RXStartList },
{ "rx rexx-script - execute ARexx macro", "RX", 2, CmdRexx },
{ "saveprefs - save dd prefs to disk", "SAVEPREFS", 9, CmdSavePrefs },
{ "set {addr} {val} - set address to val", "SET", 3, CmdSet },
{ "ports - display Exec Ports List", "PORTS", 5, CmdPorts },
{ "process {expr} - display process {at expression}", "PROCESS", 7, CmdProcess },
{ "resources - display Exec Resource List", "RESOURCES", 9, CmdResources },
{ "quit - _exit(20) & quit dd", "QUIT", 4, CmdQuit },
{ "refresh - refresh the window", "REFRESH", 7, CmdRefresh },
{ "registers - toggle the register display", "REGISTERS", 9, CmdRegs },
{ "reset - _exit(20) & restart program", "RESET", 5, CmdReset },
{ "rstep - toggle library call auto stepover flag", "RSTEP", 5, CmdRStep },
{ "source {expr} - change to source mode {at expression}", "SOURCE", 6, CmdSource },
{ "step {expr} - step program one instruction or range", "STEP", 4, CmdStep },
{ "symbols {expr} - display symbol {at expr}", "SYMBOLS", 7, CmdSymbol },
{ "symlist - display sorted symbol list", "SYMLIST", 7, CmdSymList },
{ "tasks - display Exec Task Lists", "TASKS", 5, CmdTasks },
{ "unalias - restore command with arexx script", "UNALIAS", 7, CmdUnAlias },
{ "up - move display up one line", "UP", 2, CmdUp },
{ "watchbyte {expr} - set/clear (toggle) byte watchpoints", "WATCHBYTE", 9, CmdWatchBytes },
{ "watchclear - clear all watchpoints", "WATCHCLEAR", 10, CmdWatchClear },
{ "watchlong {expr} - set/clear (toggle) long watchpoints", "WATCHLONG", 9, CmdWatchLongs },
{ "watchword {expr} - set/clear (toggle) word watchpoints", "WATCHWORD", 9, CmdWatchWords },
{ "words {expr} - display words {at expression}", "WORDS", 5, CmdWords },
{ "", NULL, 0, NULL }
};
char *HelpTable[] = {
"NOTES",
"MOUSE CLICK:",
"You can click the mouse on a label, register, or address",
"To apply it to the command line. The operators displayed",
"in the command line are there for the express purpose of",
"clicking on them. Clicking on '<' cancels a line, Clicking",
"on '>' executes it",
"",
"You can also click to the right of the command line to",
"execute the current command. Function key equivalents",
"may be executed with a mouse click by clicking on the",
"number (e.g. the '4' in '4:bytes')",
"",
"EXPRESSION:",
"A C expression evaluator allowing parenthesis and most C",
"operators, including longword indirection with *",
"",
"Note that C constants are used, so hex values must be",
"preceeded by 0x, octal with 0, decimal by default.",
""
};
// ************
char *default_fkeys[10] = {
"source",
"mixed",
"dism",
"bytes",
"symbols",
"pc",
"step",
"over",
"reset",
"go"
};
Prototype char fkeys[10][16];
char fkeys[10][16];
void RefreshFKeys(BOOL fullRefresh) {
UWORD i;
if(fullRefresh == -1) {
ScrPlain();
ScrRowCol(CurDisplay->ds_ScrRows, 2);
ScrDull();
for (i=0; i<10; i++) {
ScrPrintf("%d:%s ", i+1, fkeys[i]);
}
ScrPlain();
ScrEOL();
ScrFlush();
draw_fkey_boxes();
}
}
void init_function_keys(void)
{
int i;
memset((char *)fkeys,0,sizeof(fkeys));
for(i=0; i<10; i++)strcpy(fkeys[i],default_fkeys[i]);
}
BOOL FunctionKey(UWORD num) {
if (num < 10) return DoCommand(fkeys[num]);
return 0;
}
BOOL HelpKey(void) {
return DoCommand("help");
}
BOOL CmdFKey(char *args) {
char *ptr;
int n;
if(ptr = strchr(args,' ')) { // if there is a slot
*ptr++ = NULL;
if(((n = strtol(args,NULL,10)) > 0) && (n <= 10)) {
if(*ptr) { // and if there is a definition
strncpy(fkeys[n-1],ptr,16);
ScrStatus("Function key set");
RefreshFKeys(-1);
return TRUE;
}
}
}
ScrStatus("*** Can't set function key %d",n);
return FALSE;
}
// ************
// Handle Rexx Command. This routine looks in current directory, then
// searches dcc:rexx/
BOOL CmdRexx(char *arg) {
long rc = 1;
char *res;
long ec;
char buf[128];
// don't add a . if they already have one
if(!strchr(arg,'.'))sprintf(buf, "%s.dd", arg);
else strcpy(buf, arg);
rc = PlaceRexxCommand(NULL, buf, &res, &ec);
if (res) {
ScrStatus(res);
free(res);
}
if (ec || rc) {
// try in dcc:rexx
sprintf(buf, "dcc:rexx/%s.dd", arg);
rc = PlaceRexxCommand(NULL, buf, &res, &ec);
if (res) {
ScrStatus(res);
free(res);
}
if (ec || rc)return FALSE;
}
return TRUE;
}
BOOL CmdSavePrefs(char *args) {
WINDOW *window = CurDisplay->ds_Win;
dprefs.left = window->LeftEdge; dprefs.top = window->TopEdge;
dprefs.width = window->Width; dprefs.height = window->Height;
WritePrefs();
ScrStatus("Wrote Prefs");
return TRUE;
}
BOOL CmdInfo(char *args) {
ListInfo(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdExecBase(char *args) {
ListExecBase(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdResources(char *args) {
ListResources(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdIntrs(char *args) {
ListIntrs(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdPorts(char *args) {
ListPorts(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdSymList(char *args) {
ListSymbols(CurDisplay);
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdTasks(char *args) {
ListTasks(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdLibs(char *args) {
ListLibs(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdDevices(char *args) {
ListDevices(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdMemList(char *args) {
ListMemList(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdDosBase(char *args) {
ListDosBase(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdProcess(char *args) {
ListProcess(CurDisplay);
/*CurDisplay->ds_ListTop = (DLIST *)CurDisplay->ds_List.lh_Head;*/
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdOffsets(char *args) {
CurDisplay->ds_DisplayOffsets = !CurDisplay->ds_DisplayOffsets;
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdDown(char *args) {
switch (CurDisplay->ds_DisplayMode) {
case DISPLAY_DISM: return DownDism();
case DISPLAY_SOURCE: return DownSource();
case DISPLAY_MIXED: return DownMixed();
case DISPLAY_BYTES: return DownBytes();
case DISPLAY_WORDS: return DownWords();
case DISPLAY_LONGS: return DownLongs();
case DISPLAY_HUNKS: return DownHunks();
case DISPLAY_BREAK: return DownBreak();
case DISPLAY_HELP: return DownHelp();
case DISPLAY_SYMBOL: return DownSymbol();
case DISPLAY_DOSBASE:
case DISPLAY_PROCESS:
case DISPLAY_INFO:
case DISPLAY_EXECBASE:
case DISPLAY_RESOURCES:
case DISPLAY_INTRS:
case DISPLAY_PORTS:
case DISPLAY_TASKS:
case DISPLAY_LIBS:
case DISPLAY_DEVICES:
case DISPLAY_MEMLIST:
case DISPLAY_SYMLIST:
case DISPLAY_REXXLIST: return DownList();
default: break;
}
return TRUE;
}
BOOL CmdPageDown(char *args) {
switch (CurDisplay->ds_DisplayMode) {
case DISPLAY_DISM: return PageDownDism();
case DISPLAY_SOURCE: return PageDownSource();
case DISPLAY_MIXED: return PageDownMixed();
case DISPLAY_BYTES: return PageDownHex();
case DISPLAY_WORDS: return PageDownHex();
case DISPLAY_LONGS: return PageDownHex();
case DISPLAY_HUNKS: return DownHunks();
case DISPLAY_BREAK: return DownBreak();
case DISPLAY_HELP: return DownHelp();
case DISPLAY_SYMBOL: return PageDownSymbol();
case DISPLAY_DOSBASE:
case DISPLAY_PROCESS:
case DISPLAY_INFO:
case DISPLAY_EXECBASE:
case DISPLAY_RESOURCES:
case DISPLAY_INTRS:
case DISPLAY_PORTS:
case DISPLAY_TASKS:
case DISPLAY_LIBS:
case DISPLAY_DEVICES:
case DISPLAY_MEMLIST:
case DISPLAY_SYMLIST:
case DISPLAY_REXXLIST: return PageDownList();
default: break;
}
return TRUE;
}
BOOL CmdPageUp(char *args) {
switch (CurDisplay->ds_DisplayMode) {
case DISPLAY_DISM: return PageUpDism();
case DISPLAY_SOURCE: return PageUpSource();
case DISPLAY_MIXED: return PageUpMixed();
case DISPLAY_BYTES: return PageUpHex();
case DISPLAY_WORDS: return PageUpHex();
case DISPLAY_LONGS: return PageUpHex();
case DISPLAY_HUNKS: return UpHunks();
case DISPLAY_BREAK: return UpBreak();
case DISPLAY_HELP: return UpHelp();
case DISPLAY_SYMBOL: return PageUpSymbol();
case DISPLAY_DOSBASE:
case DISPLAY_PROCESS:
case DISPLAY_INFO:
case DISPLAY_EXECBASE:
case DISPLAY_RESOURCES:
case DISPLAY_INTRS:
case DISPLAY_PORTS:
case DISPLAY_TASKS:
case DISPLAY_LIBS:
case DISPLAY_DEVICES:
case DISPLAY_MEMLIST:
case DISPLAY_SYMLIST:
case DISPLAY_REXXLIST: return PageUpList();
default: break;
}
return TRUE;
}
BOOL CmdUp(char *args) {
switch (CurDisplay->ds_DisplayMode) {
case DISPLAY_DISM: return UpDism();
case DISPLAY_SOURCE: return UpSource();
case DISPLAY_MIXED: return UpMixed();
case DISPLAY_BYTES: return UpBytes();
case DISPLAY_WORDS: return UpWords();
case DISPLAY_LONGS: return UpLongs();
case DISPLAY_HUNKS: return UpHunks();
case DISPLAY_BREAK: return UpBreak();
case DISPLAY_HELP: return UpHelp();
case DISPLAY_SYMBOL: return UpSymbol();
case DISPLAY_DOSBASE:
case DISPLAY_PROCESS:
case DISPLAY_INFO:
case DISPLAY_EXECBASE:
case DISPLAY_RESOURCES:
case DISPLAY_INTRS:
case DISPLAY_PORTS:
case DISPLAY_TASKS:
case DISPLAY_LIBS:
case DISPLAY_DEVICES:
case DISPLAY_MEMLIST:
case DISPLAY_SYMLIST:
case DISPLAY_REXXLIST: return UpList();
default: break;
}
return TRUE;
}
BOOL CmdSource(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_SOURCE, 1);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = val;
CurDisplay->ds_WindowTopLine = 0;
}
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdDism(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_DISM, 1);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = val;
}
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdRegs(char *args) {
CurDisplay->ds_RegFlag = (CurDisplay->ds_RegFlag) ? 0 : 1;
CurDisplay->ds_RegTouched = TRUE;
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdEval(char *args) {
ULONG val;
short undef;
BOOL r = TRUE;
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) {
r = FALSE;
ScrStatus("Result undefined");
} else {
char buf[128];
OffsetAddressBuf(val, buf);
ScrStatus("Result %d (0x%08lx) (%s)", val, val, buf);
}
}
return r;
}
BOOL CmdOpen(char *args) {
DBugDisp *disp, *olddisp;
disp = ScrOpen(FALSE, TRUE, DefaultPubName);
if(*args && disp) {
olddisp = CurDisplay;
CurDisplay = disp;
DoCommand(args);
InitCommand();
ScrCursoff();
RefreshCommand(TRUE);
ScrCurson();
SetDisplayMode(CurDisplay->ds_DisplayMode, 1); // make this the default for this window
CurDisplay = olddisp;
}
return TRUE;
}
BOOL CmdClose(char *args) {
RequestCloseDisplay(CurDisplay,TRUE);
return TRUE;
}
BOOL CmdMixed(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_MIXED, 1);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = val;
CurDisplay->ds_WindowTopLine = 0;
}
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdBytes(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_BYTES, 1);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = val;
}
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdWords(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_WORDS, 1);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = val;
}
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdLongs(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_LONGS, 1);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = val;
}
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdBreakpoint(char *args) {
SetDisplayMode(DISPLAY_BREAK, 0);
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdBP(char *args) {
ULONG val;
short undef;
if (*args) {
if (!strnicmp(args, "ALL", 3)) {
SetAllBreakpoints();
ScrStatus("Breakpoint table set");
RefreshAllWindows(TRUE);
return TRUE;
}
val = ParseExp(args, &undef, strlen(args));
if (undef || !val) val = CurDisplay->ds_WindowTop;
// check if break point is already set
// if so, clear it
if(IsBreakpoint(val))return(CmdClear(args));
if (SetBreakpoint(val, 1, BP_SET)) {
RefreshAllWindows(TRUE);
ScrStatus("BP set at 0x%08x", val);
return TRUE;
}
else {
ScrStatus("*** Can't set BP at 0x%08x", val);
return FALSE;
}
}
ScrStatus("*** Usage: bp {expr}");
return FALSE;
}
BOOL CmdClear(char *args) {
ULONG val;
short undef;
if (*args) {
if (!strnicmp(args, "ALL", 3)) {
InitBreakpoints();
ScrStatus("Breakpoint table cleared");
RefreshAllWindows(TRUE);
return TRUE;
}
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
if (ClearBreakpoint(val)) {
RefreshAllWindows(TRUE);
ScrStatus("BP cleared at 0x%08x", val);
return TRUE;
}
else {
ScrStatus("*** Can't clear BP at 0x%08x", val);
return FALSE;
}
}
ScrStatus("*** Usage: clear {expr}");
return FALSE;
}
BOOL CmdHunks(char *args) {
SetDisplayMode(DISPLAY_HUNKS, 0);
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdSymbol(char *args) {
ULONG val;
short undef;
SetDisplayMode(DISPLAY_SYMBOL, 0);
if (*args) {
val = ParseExp(args, &undef, strlen(args));
if (undef) return FALSE;
CurDisplay->ds_WindowTop = SymbolIndexOfAddr(val); // pseudo index
}
RefreshWindow(TRUE);
return TRUE;
}
static char *casts[3] = { "(BYTE)","(WORD)","(LONG)"};
BOOL CmdSet(char *args) {
UBYTE *adb;
UWORD *adw;
ULONG *adl;
ULONG val=0, addr, address;
short undef = 1;
int i, castsize = 2;
char *ptr,*ptr1;
if (*args) {
ptr = args;
ptr1 = strchr(args,' '); // split into two strings
if(ptr1) {
*ptr1++ = NULL;
for(i=0; i<3; i++) { // check for cast operator
if(!stricmp(casts[i],ptr)) {
castsize = i;
// adjust the pointers
ptr = ptr1;
if(!(ptr1 = strchr(ptr,' ')))return FALSE;
*ptr1++ = NULL; // split the string
break;
}
}
// check it its a register
if((strlen(ptr) >= 3) && (ptr[2]==':')) {
ptr[2]=' ';
if((addr = (ULONG)RegisterAddress(ptr)))undef = 0; // yes, its a register
}
if(undef)addr = ParseExp(ptr, &undef, strlen(ptr)); // must be an address
if(!undef) {
val = ParseExp(ptr1, &undef, strlen(ptr1));
if (address = ValidMemCheck((ULONG)addr)) {
switch (castsize) {
case 0:
adb = (UBYTE *)address;
*adb = (BYTE)val;
break;
case 1:
adw = (UWORD *)address;
*adw = (WORD)val;
break;
case 2:
adl = (ULONG *)address;
*adl = (LONG)val;
break;
default:
return FALSE;
}
ScrStatus("%08X set to %X",addr,val);
RefreshAllWindows(FALSE);
return TRUE;
}
ScrStatus("*** Can't set %08X to %X",addr,val);
return FALSE;
}
}
}
ScrStatus("*** Usage: set {expr} {value}");
return FALSE;
}
BOOL CmdAgain(char *args) {
return DoCommand(lastCommand);
}
BOOL CmdChangeWindow(char *args) {
char *ptr, *ptr1;
int size[4] = {-1, -1, -1, -1};
int i = -1;
if(((struct Library *)SysBase)->lib_Version >= 36) {
ptr = args;
while ((++i < 4) && *ptr) {
size[i]=strtol(ptr,&ptr1,10);
ptr = ptr1;
}
if(i == 4) {
ChangeWindowBox(CurDisplay->ds_Win,size[0],size[1],size[2],size[3]);
ScrStatus("Window repositioned\n");
return TRUE;
}
ScrStatus("*** Usage: ChangeWindow {left} {top} {width} {height}");
}
return FALSE;
}
BOOL StepTargetRange(ULONG addressLow, ULONG addressHi) {
// step within the address range given
// (execute at least once, though)
do {
CopyLastState();
programSR |= 0x8000;
EnterProgram();
programSR &= 0x7fff;
} while((programPC >= addressLow) && (programPC <= addressHi));
if (CurDisplay->ds_DisplayMode > DISPLAY_MIXED)
SetDisplayMode(CurDisplay->ds_PreferedMode, 0);
if (programState == STATE_TRACE)programState = STATE_STEPPED;
if ((programPC <= CurDisplay->ds_WindowTop) || (programPC >= CurDisplay->ds_WindowBot)) {
CurDisplay->ds_WindowTop = programPC;
ForceFullRefresh = 1;
}
return (programState == STATE_STEPPED);
}
BOOL StepTarget(void) {
CopyLastState();
programSR |= 0x8000;
EnterProgram();
programSR &= 0x7fff;
if (CurDisplay->ds_DisplayMode > DISPLAY_MIXED)
SetDisplayMode(CurDisplay->ds_PreferedMode, 0);
if (programState == STATE_TRACE)programState = STATE_STEPPED;
if ((programPC <= CurDisplay->ds_WindowTop) || (programPC >= CurDisplay->ds_WindowBot)) {
CurDisplay->ds_WindowTop = programPC;
ForceFullRefresh = 1;
}
return (programState == STATE_STEPPED);
}
BOOL CmdRStep(char *args)
{
RStepFlag = !RStepFlag;
if(!RStepFlag)ScrStatus("Library step over off");
else ScrStatus("Library step over on");
return TRUE;
}
// If an argument given, will do a range single step
BOOL CmdStep(char *args) {
BOOL result, fullRefresh = FALSE;
ULONG endrange = 0;
short undef;
// process the range argument
if(*args) {
// stop before the specified instruction
endrange = ParseExp(args, &undef, strlen(args)) - 2;
if (undef) endrange = 0;
}
switch (CurDisplay->ds_PreferedMode) {
case DISPLAY_SOURCE: {
ULONG address = programPC, line = 0;
WORD type, breakflag = 0;
if(CurrentMixedLine(&address,&line,NULL) == MIXTYPE_SOURCE) {
// find end of address range for the target range
while((type = NextMixedLine(&address,&line,NULL)) == MIXTYPE_SOURCE);
while(type == MIXTYPE_DISM) {
endrange = address;
while(NextMixedLine(&address,&line,NULL) == MIXTYPE_DISM) {
endrange = address;
}
if(endrange >= programPC) {
if(!RStepFlag)result = StepTargetRange(programPC,endrange);
else result = RStepTargetRange(programPC,endrange);
address = programPC;
line = 0;
if(CurrentMixedLine(&address,&line,NULL) == MIXTYPE_DISM)continue;
breakflag = TRUE; // switch break
break;
}
}
if(breakflag)break;
}
#if 0
// This doesn't really work all that well
// So its gone
DEBUG *debug;
while (1) {
if (!OverTarget()) { result = FALSE; break; }
debug = FindDebug(programPC);
if (!debug)
result = FALSE;
else {
if (FindSource(debug, programPC)) { result = TRUE; break; }
}
}
break;
#endif
}
case DISPLAY_MIXED:
case DISPLAY_DISM:
if(endrange) {
if(!RStepFlag)result = StepTargetRange(programPC,endrange);
else result = RStepTargetRange(programPC,endrange);
}
else {
if(!RStepFlag)result = StepTarget();
else result = RStepTarget();
}
break;
}
RefreshAllWindows(FALSE);
return result;
}
BOOL OverTargetRange(ULONG addressLow, ULONG addressHi) {
char buf[128];
ULONG size, twp;
UWORD *pw;
do {
pw = (UWORD *)programPC;
// over at a forward branch is treated as a regular StepTarget()
// Check for Bcc instruction
if (((*pw & 0xf000) == 0x6000) && ((*pw & 0xff00) != 0x6100)) {
if ((*pw & 0xff) == 0xff) { // 32-bit displacement (020+ only)
ULONG *pl = (ULONG *)&pw[1];
if (*pl > 0) {
StepTarget();
continue;
}
}
else if ((*pw & 0xff) == 0x00) { // 16-bit displacement
UWORD *lpw = (UWORD *)&pw[1];
if (*lpw > 0) {
StepTarget();
continue;
}
}
else { // 8-bit displacement
if ((*pw & 0xff) < 0x80) {
StepTarget();
continue;
}
}
}
size = Disassemble(programPC, programPC, buf);
// over at RTS, or JMP is treated as a regular StepTarget()
if (!strnicmp(buf, "RTS", 3) || !strnicmp(buf, "JMP", 3)) {
StepTarget();
continue;
}
// set temp breakpoint at instruction after current PC
if(TypeOfMem((UBYTE *)((ULONG)programPC)+size)) {
SetTempBreakpoint(programPC+size);
if (!GoTarget()) return FALSE;
}
else {
twp = programPC+size;
while(twp != programPC) {
if(!StepTarget()) {
if(programState == STATE_EXITED)return FALSE;
break;
}
}
if(programState == STATE_STEPPED)programState = STATE_STEPPEDOVER;
}
if (programPC < CurDisplay->ds_WindowTop || programPC > CurDisplay->ds_WindowBot) {
CurDisplay->ds_WindowTop = programPC;
ForceFullRefresh = 1;
}
} while ((programPC >= addressLow) && (programPC <= addressHi));
return (programState == STATE_STEPPEDOVER);
}
BOOL OverTarget(void) {
char buf[128];
ULONG size, twp;
UWORD *pw = (UWORD *)programPC;
// over at a forward branch is treated as a regular StepTarget()
if (((*pw & 0xf000) == 0x6000) && ((*pw & 0xff00) != 0x6100)) { // Bcc instruction
if ((*pw & 0xff) == 0xff) { // 32-bit displacement (020+ only)
ULONG *pl = (ULONG *)&pw[1];
if (*pl > 0) return StepTarget();
}
else if ((*pw & 0xff) == 0x00) { // 16-bit displacement
UWORD *lpw = (UWORD *)&pw[1];
if (*lpw > 0) return StepTarget();
}
else { // 8-bit displacement
if ((*pw & 0xff) < 0x80) {
return StepTarget();
}
}
}
size = Disassemble(programPC, programPC, buf);
// over at RTS, or JMP is treated as a regular StepTarget()
if (!strnicmp(buf, "RTS", 3) || !strnicmp(buf, "JMP", 3)) return StepTarget();
// set temp breakpoint at instruction after current PC
if(TypeOfMem((UBYTE *)((ULONG)programPC)+size)) {
SetTempBreakpoint(programPC+size);
if (!GoTarget()) return FALSE;
}
else {
twp = programPC+size;
while(twp != programPC) {
if(!StepTarget()) {
if(programState == STATE_EXITED)return FALSE;
break;
}
}
if(programState == STATE_STEPPED)programState = STATE_STEPPEDOVER;
}
if ((programPC <= CurDisplay->ds_WindowTop) || (programPC >= CurDisplay->ds_WindowBot)) {
CurDisplay->ds_WindowTop = programPC;
ForceFullRefresh = 1;
}
return (programState == STATE_STEPPEDOVER);
}
// Rom Step Target
// Automatically steps over library calls
// otherwise single steps
BOOL RStepTarget(void) {
char buf[128];
ULONG size, twp;
size = Disassemble(programPC, programPC, buf);
if (strnicmp(buf, "JSR", 3))return StepTarget();
if(!strchr(buf,'-') || !strstr(buf,"(A6)"))return StepTarget();
// well, its a JSR negative offset through A6, so lets skip over
// set temp breakpoint at instruction after current PC
if(TypeOfMem((UBYTE *)((ULONG)programPC)+size)) {
SetTempBreakpoint(programPC+size);
if (!GoTarget()) return FALSE;
}
else {
// we're in rom; setting the breakpoint will not work well
twp = programPC+size;
while(twp != programPC) {
if(!StepTarget()) {
if(programState == STATE_EXITED)return FALSE;
break;
}
}
if(programState == STATE_STEPPED)programState = STATE_STEPPEDOVER;
}
if (programPC <= CurDisplay->ds_WindowTop || programPC >= CurDisplay->ds_WindowBot) {
CurDisplay->ds_WindowTop = programPC;
ForceFullRefresh = 1;
}
return (programState == STATE_STEPPEDOVER);
}
BOOL RStepTargetRange(ULONG addressLow, ULONG addressHi) {
char buf[128];
ULONG size, twp;
do {
size = Disassemble(programPC, programPC, buf);
if (strnicmp(buf, "JSR", 3))return StepTarget();
if(!strchr(buf,'-') || !strstr(buf,"(A6)"))return StepTarget();
// well, its a JSR negative offset through A6, so lets skip over
// set temp breakpoint at instruction after current PC
if(TypeOfMem((UBYTE *)((ULONG)programPC)+size)) {
SetTempBreakpoint(programPC+size);
if (!GoTarget()) return FALSE;
}
else {
twp = programPC+size;
while(twp != programPC) {
if(!StepTarget()) {
if(programState == STATE_EXITED)return FALSE;
break;
}
}
if(programState == STATE_STEPPED)programState = STATE_STEPPEDOVER;
}
if (programPC < CurDisplay->ds_WindowTop || programPC > CurDisplay->ds_WindowBot) {
CurDisplay->ds_WindowTop = programPC;
ForceFullRefresh = 1;
}
} while ((programPC >= addressLow) && (programPC <= addressHi));
return (programState == STATE_STEPPEDOVER);
}
BOOL CmdOver(char *args) {
BOOL result;
ULONG endrange = 0;
short undef;
// process the range argument
if(*args) {
// stop before the specified instruction
endrange = ParseExp(args, &undef, strlen(args)) - 2;
if (undef) endrange = 0;
}
switch (CurDisplay->ds_PreferedMode) {
case DISPLAY_SOURCE: {
ULONG address = programPC, line = 0;
WORD type, breakflag = 0;
type = CurrentMixedLine(&address,&line,NULL);
if (type == 0)type = NextMixedLine(&address, &line, NULL);
if(type == MIXTYPE_SOURCE) {
// find end of address range for the target range
while((type = NextMixedLine(&address,&line,NULL)) == MIXTYPE_SOURCE);
while(type == MIXTYPE_DISM) {
endrange = address;
while(NextMixedLine(&address,&line,NULL) == MIXTYPE_DISM)endrange = address;
if(endrange >= programPC) {
result = OverTargetRange(programPC,endrange);
// find the next source line (if not on a source line)
// and execute to it
address = programPC; // on a source line yet ?
line = 0;
type = CurrentMixedLine(&address,&line,NULL);
}
}
if(type == MIXTYPE_SOURCE)break;
}
// drop through to mixed case
endrange = 0;
}
case DISPLAY_MIXED:
case DISPLAY_DISM:
if(endrange)result = OverTargetRange(programPC,endrange);
else result = OverTarget();
break;
}
RefreshAllWindows(FALSE);
return result;
}
BOOL CmdRefresh(char *args) {
RefreshWindow(TRUE);
}
BOOL CmdReset(char *args) {
ULONG i;
if (programState != STATE_RESET && programState != STATE_EXITED &&
(LookupSymbol("@exit", &i) || LookupSymbol("_exit", &i))) {
programPC = i;
GoTarget();
if (programState != STATE_EXITED) {
RefreshWindow(TRUE);
return FALSE;
}
}
ResetTarget();
RefreshWindow(TRUE);
ScrStatus("Target Reset");
return TRUE;
}
BOOL GoTarget(void) {
if (IsBreakpoint(programPC)) {
programSR |= 0x8000;
EnterDebugger();
programSR &= 0x7fff;
if (programState != STATE_TRACE) return FALSE;
}
InstallBreakpoints();
CopyLastState();
EnterProgram();
CheckBreakpoints();
if(CurDisplay) {
if (CurDisplay->ds_DisplayMode > DISPLAY_MIXED)
SetDisplayMode(CurDisplay->ds_PreferedMode, 0);
if (programPC < CurDisplay->ds_WindowTop || programPC > CurDisplay->ds_WindowBot)
CurDisplay->ds_WindowTop = programPC;
}
return TRUE;
}
Local void CopyLastState(void) {
lastState = programState;
lastSR = programSR;
lastPC = programPC;
lastD0 = programD0; lastD1 = programD1; lastD2 = programD2; lastD3 = programD3;
lastD4 = programD4; lastD5 = programD5; lastD6 = programD6; lastD7 = programD7;
lastA0 = programA0; lastA1 = programA1; lastA2 = programA2; lastA3 = programA3;
lastA4 = programA4; lastA5 = programA5; lastA6 = programA6; lastA7 = programA7;
}
BOOL CmdGo(char *args) {
char symbol[128];
char *pd;
ULONG addr;
while (*args) {
while (*args == ' ' || *args == '\t') args++;
if (*args) {
WORD undef;
pd = &symbol[0];
while (*args && *args != ' ' && *args != '\t') *pd++ = *args++;
*pd = '\0';
addr = ParseExp(symbol, &undef, strlen(symbol));
if (undef) return FALSE;
if (!SetBreakpoint(addr, 1, BP_GROUP)) return FALSE;
}
}
GoTarget();
// RefreshWindow(FALSE);
RefreshAllWindows(FALSE); // just in case a breakpoint was hit.
// probably should limit refresh to
// source, asm, mixed, and bp wondows
return TRUE;
}
BOOL CmdQuit(char *args) {
ULONG i;
if (programState != STATE_RESET && programState != STATE_EXITED) {
if (LookupSymbol("@exit", &i)) {
programD0 = RETURN_FAIL;
programPC = i;
GoTarget();
if (programState != STATE_EXITED) {
if(CurDisplay)RefreshWindow(TRUE);
return FALSE;
}
}
else if (LookupSymbol("_exit", &i)) {
ULONG *pl = (ULONG *)programA7;
--pl;
*pl = RETURN_FAIL;
programA7 = (ULONG)pl;
programPC = i;
GoTarget();
if (programState != STATE_EXITED) {
if(CurDisplay) {
RefreshWindow(TRUE);
}
return FALSE;
}
// pick up return code and load into D0
programD0 = *pl;
}
}
printf("\n*** %s Exited, code %d\n", targetName, programD0);
exit(0);
return TRUE;
}
BOOL CmdHelp(char *args) {
if (*args == 0 && CurDisplay->ds_DisplayMode == DISPLAY_HELP) {
SetDisplayMode(CurDisplay->ds_PreferedMode, 0);
} else {
SetDisplayMode(DISPLAY_HELP, 0);
if (CurDisplay->ds_WindowTop < 0)
CurDisplay->ds_WindowTop = 0;
if (CurDisplay->ds_WindowTop > arysize(commandTable) + arysize(HelpTable))
CurDisplay->ds_WindowTop = arysize(commandTable) + arysize(HelpTable) - 1;
}
RefreshWindow(TRUE);
return TRUE;
}
// ************
BOOL CmdWatchClear(char *args) {
InitWatchpoints();
RefreshWindow(TRUE);
return TRUE;
}
BOOL CmdWatchBytes(char *args) {
char symbol[128];
char *pd;
BOOL fullRefresh = FALSE;
while (*args) {
while (*args == ' ' || *args == '\t') args++;
if (*args) {
pd = &symbol[0];
while (*args && *args != ' ' && *args != '\t') *pd++ = *args++;
*pd = '\0';
if (IsWatchpoint(symbol)) {
if (!ClearWatchpoint(symbol)) return FALSE;
fullRefresh = TRUE;
}
else {
if (!SetWatchpoint(symbol, WP_BYTES)) return FALSE;
}
fullRefresh = TRUE;
}
}
RefreshWindow(fullRefresh);
return TRUE;
}
BOOL CmdWatchWords(char *args) {
char symbol[128];
char *pd;
BOOL fullRefresh = FALSE;
while (*args) {
while (*args == ' ' || *args == '\t') args++;
if (*args) {
pd = &symbol[0];
while (*args && *args != ' ' && *args != '\t') *pd++ = *args++;
*pd = '\0';
if (IsWatchpoint(symbol)) {
if (!ClearWatchpoint(symbol)) return FALSE;
fullRefresh = TRUE;
}
else if (!SetWatchpoint(symbol, WP_WORDS)) return FALSE;
fullRefresh = TRUE;
}
}
RefreshWindow(fullRefresh);
return TRUE;
}
BOOL CmdWatchLongs(char *args) {
char symbol[128];
char *pd;
BOOL fullRefresh = FALSE;
while (*args) {
while (*args == ' ' || *args == '\t') args++;
if (*args) {
pd = &symbol[0];
while (*args && *args != ' ' && *args != '\t') *pd++ = *args++;
*pd = '\0';
if (IsWatchpoint(symbol)) {
if (!ClearWatchpoint(symbol)) return FALSE;
fullRefresh = TRUE;
}
else if (!SetWatchpoint(symbol, WP_LONGS)) return FALSE;
fullRefresh = TRUE;
}
}
RefreshWindow(fullRefresh);
return TRUE;
}
// ************
BOOL UpHelp(void) {
if (CurDisplay->ds_WindowTop) {
CurDisplay->ds_LastRefreshTop = --CurDisplay->ds_WindowTop;
ScrScrolldown();
RefreshHelp(1, 0, CurDisplay->ds_WindowTop);
}
return TRUE;
}
BOOL DownHelp(void) {
CurDisplay->ds_LastRefreshTop = ++CurDisplay->ds_WindowTop;
ScrScrollup();
RefreshHelp(1, 0, CurDisplay->ds_WindowTop + ScrMainBodyRange(NULL,NULL) - 1);
}
WORD RefreshHelp(WORD maxLines, BOOL fullRefresh, LONG index) {
WORD count = 0;
do_scroller();
if (fullRefresh) {
SetTitle(NULL,NULL);
#if 0
ScrInverse();
ScrPrintf("ON-LINE HELP");
#endif
if(CurDisplay->ds_RegFlag) {
Newline();
++count;
if (--maxLines <= 0)return count;
}
}
ScrPlain();
while (maxLines > 0 && index < arysize(commandTable) + arysize(HelpTable)) {
if (index >= 0) {
if (index >= arysize(commandTable)) {
ScrPuts(HelpTable[index-arysize(commandTable)]);
}
else {
ScrPuts(commandTable[index].helpText);
}
Newline();
--maxLines;
++count;
}
++index;
}
return count;
}
int HelpSize(void)
{
return arysize(commandTable) + arysize(HelpTable) + 4;
}
BOOL CmdAlias(char *args)
{
short i;
for (i=0; commandTable[i].command; i++) {
if (!strnicmp(commandTable[i].command, args, commandTable[i].commandLen)) {
dprefs.alias[i] = 1;
return(TRUE);
}
}
return(FALSE);
}
BOOL CmdUnAlias(char *args)
{
short i;
for (i=0; commandTable[i].command; i++) {
if (!strnicmp(commandTable[i].command, args, commandTable[i].commandLen)) {
dprefs.alias[i] = 0;
return(TRUE);
}
}
return(FALSE);
}
BOOL CmdJump(char *args)
{
struct Screen *scr;
DBugDisp *disp, *olddisp;
// jump only works in 2.0
if(((struct Library *)SysBase)->lib_Version >= 36) {
if(! *args) { // we were not given a name to jump to
// so lets go to next pub screen
if(!(scr=CurDisplay->ds_Win->WScreen))return FALSE;
if(!NextPubScreen(scr,DefaultPubName))return FALSE;
}
else strcpy(DefaultPubName,args);
RequestCloseDisplay(CurDisplay,TRUE);
if(disp = ScrOpen(FALSE, TRUE, DefaultPubName)) {
olddisp = CurDisplay;
CurDisplay = disp;
InitCommand();
ScrCursoff();
ScrStatus("Jumped");
RefreshCommand(-1);
ScrCurson();
CurDisplay = olddisp;
return TRUE;
}
return FALSE;
}
}
BOOL CmdTitle(char *args)
{
char *ptr;
int n;
if(ptr = strchr(args,' ')) { // if there is a slot
*ptr++ = NULL;
if((n = FindSlot(args)) >= 0) {
if(*ptr) { // if there is a title given
set_menu_item(n,NM_TITLE,ptr,"","");
return TRUE;
}
}
}
return FALSE;
}
BOOL CmdItem(char *args)
{
return ProcessMenuItem(args,NM_ITEM);
}
BOOL CmdSubItem(char *args)
{
return ProcessMenuItem(args,NM_SUB);
}
BOOL CmdBar(char *args)
{
int n;
if((n = FindSlot(args)) >= 0)set_menu_item(n,NM_BAR,"","","");
return(TRUE);
}
BOOL CmdEnd(char *args)
{
int n;
if((n = strtol(args,NULL,10)) >= 0)set_menu_item(n,NM_END,"","","");
return(TRUE);
}
BOOL CmdMenus(char *args)
{
return enable_menus();
}
// ************
char *SkipBlanks(char *s) { while (*s == ' ' || *s == '\t') s++; return s; }
BOOL DoCommand(char *command) {
ULONG val;
short i, undef, j = 2;
BOOL res;
UBYTE *ptr;
oldcol = 0xFFFE; // cancel a possible double click
if(! *command) {
ScrStatus("Ready"); // don't bother to search, they just hit a return
return TRUE;
}
ptr = command;
while (j--) {
for (i=0; commandTable[i].command; i++) {
if (!strnicmp(commandTable[i].command, ptr, commandTable[i].commandLen)) {
if(dprefs.alias[i]) {
// try to run the correct Arexx script
res = CmdRexx(ptr);
ShortStatus(1,ptr);
return res;
}
ShortStatus(0,ptr);
if(j) ptr = &command[commandTable[i].commandLen];
else ptr = command;
return (*commandTable[i].func)(SkipBlanks(ptr));
}
}
// not found in table
if(j <= 0)break; // second time through
// not found in commandTable. Maybe it's an "implied display" command (expression only)
val = ParseExp(command, &undef, strlen(command));
if (!undef) {
SetDisplayMode(CurDisplay->ds_PreferedMode, 0);
CurDisplay->ds_WindowTop = val;
ScrStatus("Result is %0X",val);
RefreshWindow(TRUE);
return TRUE;
}
// allow the argument to be specified first (for convenience in entering commands)
if (ptr = strrchr(command,' ')) {
*ptr++ = 0; // split the string
}
else break;
}
// hm, see if its an arexx command
ShortStatus(2,command); // reset the display
if(CmdRexx(command)) return TRUE;
// if its here, its not a command
ScrStatus("*** Invalid Command: '%s'", command);
return FALSE;
}
// void *msg; /* RexxMsg structure if we need it */
// struct MsgPort *port; /* MsgPort structure if we need it */
// char *arg0; /* arg0 */
// char **pres; /* where to put our result if rc==0 */
long DoRexxCommand(void *msg, MPORT *port, char *arg0, char **pres) {
WORD i;
long res = 5;
memset(RexxReplyString,0,MAX_REXX_REPLY);
ShortStatus(2,arg0);
ScrCursoff();
for (i=0; commandTable[i].command; i++) {
if (!strnicmp(commandTable[i].command, arg0, commandTable[i].commandLen)) {
if ((*commandTable[i].func)(SkipBlanks(&arg0[commandTable[i].commandLen])))
res = 0;
else res = 10;
*pres = RexxReplyString;
break;
}
}
RefreshCommand(TRUE);
ScrCurson();
return res; // unrecognized command
}
// produce a shortened command status display
void ShortStatus(int mode, char *command)
{
char buf[128], *ptr , *s;
strcpy(buf,command);
if(ptr = strchr(buf,' '))*ptr=NULL; // shorten to just the command
if(mode == 0)s = "Command";
else if(mode == 1) s = "Alias";
else s = "Rexx";
ScrStatus("%s '%s'",s,buf);
}
#if 0
Prototype void kprintline(char *string);
void kprintline(char *string)
{
kprintf("[");
while(*string && (*string != '\n'))kprintf("%lc",*string++);
kprintf("]\n");
}
#endif
#if 0
Prototype void kprintlen(char *string, int len);
void kprintlen(char *string, int len)
{
kprintf("[");
while(*string && (*string != '\n') && len--)kprintf("%lc",*string++);
kprintf("]\n");
}
#endif